// Generated from antlr/tscn.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { tscnListener } from "./tscnListener";
import { tscnVisitor } from "./tscnVisitor";


export class tscnParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly INT = 13;
	public static readonly DIGIT = 14;
	public static readonly ID = 15;
	public static readonly NameChar = 16;
	public static readonly NameStartChar = 17;
	public static readonly STRING_ = 18;
	public static readonly HEX = 19;
	public static readonly HEXNUM = 20;
	public static readonly BIN = 21;
	public static readonly BINNUM = 22;
	public static readonly FLOAT_ = 23;
	public static readonly SIGN = 24;
	public static readonly WS = 25;
	public static readonly RULE_file = 0;
	public static readonly RULE_section = 1;
	public static readonly RULE_section_header = 2;
	public static readonly RULE_attribute = 3;
	public static readonly RULE_property_ = 4;
	public static readonly RULE_instance = 5;
	public static readonly RULE_dictionary = 6;
	public static readonly RULE_pair = 7;
	public static readonly RULE_array = 8;
	public static readonly RULE_value = 9;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"file", "section", "section_header", "attribute", "property_", "instance", 
		"dictionary", "pair", "array", "value",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'['", "']'", "'='", "'('", "','", "')'", "'{'", "'}'", "':'", 
		"'true'", "'false'", "'null'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, "INT", 
		"DIGIT", "ID", "NameChar", "NameStartChar", "STRING_", "HEX", "HEXNUM", 
		"BIN", "BINNUM", "FLOAT_", "SIGN", "WS",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(tscnParser._LITERAL_NAMES, tscnParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return tscnParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "tscn.g4"; }

	// @Override
	public get ruleNames(): string[] { return tscnParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return tscnParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(tscnParser._ATN, this);
	}
	// @RuleVersion(0)
	public file(): FileContext {
		let _localctx: FileContext = new FileContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, tscnParser.RULE_file);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 21;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 20;
				this.section();
				}
				}
				this.state = 23;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tscnParser.T__0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public section(): SectionContext {
		let _localctx: SectionContext = new SectionContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, tscnParser.RULE_section);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 25;
			this.section_header();
			this.state = 29;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === tscnParser.ID) {
				{
				{
				this.state = 26;
				this.property_();
				}
				}
				this.state = 31;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public section_header(): Section_headerContext {
		let _localctx: Section_headerContext = new Section_headerContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, tscnParser.RULE_section_header);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 32;
			this.match(tscnParser.T__0);
			this.state = 33;
			this.match(tscnParser.ID);
			this.state = 35;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 34;
				this.attribute();
				}
				}
				this.state = 37;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tscnParser.ID);
			this.state = 39;
			this.match(tscnParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public attribute(): AttributeContext {
		let _localctx: AttributeContext = new AttributeContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, tscnParser.RULE_attribute);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 41;
			this.match(tscnParser.ID);
			this.state = 42;
			this.match(tscnParser.T__2);
			this.state = 43;
			this.value();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public property_(): Property_Context {
		let _localctx: Property_Context = new Property_Context(this._ctx, this.state);
		this.enterRule(_localctx, 8, tscnParser.RULE_property_);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 45;
			this.match(tscnParser.ID);
			this.state = 46;
			this.match(tscnParser.T__2);
			this.state = 47;
			this.value();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public instance(): InstanceContext {
		let _localctx: InstanceContext = new InstanceContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, tscnParser.RULE_instance);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 49;
			this.match(tscnParser.ID);
			this.state = 50;
			this.match(tscnParser.T__3);
			this.state = 51;
			this.value();
			this.state = 56;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === tscnParser.T__4) {
				{
				{
				this.state = 52;
				this.match(tscnParser.T__4);
				this.state = 53;
				this.value();
				}
				}
				this.state = 58;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 59;
			this.match(tscnParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dictionary(): DictionaryContext {
		let _localctx: DictionaryContext = new DictionaryContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, tscnParser.RULE_dictionary);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 61;
			this.match(tscnParser.T__6);
			this.state = 62;
			this.pair();
			this.state = 67;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === tscnParser.T__4) {
				{
				{
				this.state = 63;
				this.match(tscnParser.T__4);
				this.state = 64;
				this.pair();
				}
				}
				this.state = 69;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 70;
			this.match(tscnParser.T__7);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public pair(): PairContext {
		let _localctx: PairContext = new PairContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, tscnParser.RULE_pair);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 72;
			this.match(tscnParser.STRING_);
			this.state = 73;
			this.match(tscnParser.T__8);
			this.state = 74;
			this.value();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public array(): ArrayContext {
		let _localctx: ArrayContext = new ArrayContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, tscnParser.RULE_array);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 76;
			this.match(tscnParser.T__0);
			this.state = 77;
			this.value();
			this.state = 84;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === tscnParser.T__4) {
				{
				{
				this.state = 78;
				this.match(tscnParser.T__4);
				this.state = 80;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << tscnParser.T__0) | (1 << tscnParser.T__6) | (1 << tscnParser.T__9) | (1 << tscnParser.T__10) | (1 << tscnParser.T__11) | (1 << tscnParser.INT) | (1 << tscnParser.ID) | (1 << tscnParser.STRING_) | (1 << tscnParser.FLOAT_))) !== 0)) {
					{
					this.state = 79;
					this.value();
					}
				}

				}
				}
				this.state = 86;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 87;
			this.match(tscnParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public value(): ValueContext {
		let _localctx: ValueContext = new ValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, tscnParser.RULE_value);
		try {
			this.state = 98;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case tscnParser.INT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 89;
				this.match(tscnParser.INT);
				}
				break;
			case tscnParser.FLOAT_:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 90;
				this.match(tscnParser.FLOAT_);
				}
				break;
			case tscnParser.STRING_:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 91;
				this.match(tscnParser.STRING_);
				}
				break;
			case tscnParser.T__6:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 92;
				this.dictionary();
				}
				break;
			case tscnParser.T__0:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 93;
				this.array();
				}
				break;
			case tscnParser.ID:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 94;
				this.instance();
				}
				break;
			case tscnParser.T__9:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 95;
				this.match(tscnParser.T__9);
				}
				break;
			case tscnParser.T__10:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 96;
				this.match(tscnParser.T__10);
				}
				break;
			case tscnParser.T__11:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 97;
				this.match(tscnParser.T__11);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x1Bg\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x03\x02\x06\x02\x18\n\x02" +
		"\r\x02\x0E\x02\x19\x03\x03\x03\x03\x07\x03\x1E\n\x03\f\x03\x0E\x03!\v" +
		"\x03\x03\x04\x03\x04\x03\x04\x06\x04&\n\x04\r\x04\x0E\x04\'\x03\x04\x03" +
		"\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x03\x06\x03\x06\x03\x06\x03" +
		"\x07\x03\x07\x03\x07\x03\x07\x03\x07\x07\x079\n\x07\f\x07\x0E\x07<\v\x07" +
		"\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x07\bD\n\b\f\b\x0E\bG\v\b\x03" +
		"\b\x03\b\x03\t\x03\t\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x05\nS\n\n\x07" +
		"\nU\n\n\f\n\x0E\nX\v\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03\v\x03\v\x03\v" +
		"\x03\v\x03\v\x03\v\x05\ve\n\v\x03\v\x02\x02\x02\f\x02\x02\x04\x02\x06" +
		"\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x02\x02\x02k\x02" +
		"\x17\x03\x02\x02\x02\x04\x1B\x03\x02\x02\x02\x06\"\x03\x02\x02\x02\b+" +
		"\x03\x02\x02\x02\n/\x03\x02\x02\x02\f3\x03\x02\x02\x02\x0E?\x03\x02\x02" +
		"\x02\x10J\x03\x02\x02\x02\x12N\x03\x02\x02\x02\x14d\x03\x02\x02\x02\x16" +
		"\x18\x05\x04\x03\x02\x17\x16\x03\x02\x02\x02\x18\x19\x03\x02\x02\x02\x19" +
		"\x17\x03\x02\x02\x02\x19\x1A\x03\x02\x02\x02\x1A\x03\x03\x02\x02\x02\x1B" +
		"\x1F\x05\x06\x04\x02\x1C\x1E\x05\n\x06\x02\x1D\x1C\x03\x02\x02\x02\x1E" +
		"!\x03\x02\x02\x02\x1F\x1D\x03\x02\x02\x02\x1F \x03\x02\x02\x02 \x05\x03" +
		"\x02\x02\x02!\x1F\x03\x02\x02\x02\"#\x07\x03\x02\x02#%\x07\x11\x02\x02" +
		"$&\x05\b\x05\x02%$\x03\x02\x02\x02&\'\x03\x02\x02\x02\'%\x03\x02\x02\x02" +
		"\'(\x03\x02\x02\x02()\x03\x02\x02\x02)*\x07\x04\x02\x02*\x07\x03\x02\x02" +
		"\x02+,\x07\x11\x02\x02,-\x07\x05\x02\x02-.\x05\x14\v\x02.\t\x03\x02\x02" +
		"\x02/0\x07\x11\x02\x0201\x07\x05\x02\x0212\x05\x14\v\x022\v\x03\x02\x02" +
		"\x0234\x07\x11\x02\x0245\x07\x06\x02\x025:\x05\x14\v\x0267\x07\x07\x02" +
		"\x0279\x05\x14\v\x0286\x03\x02\x02\x029<\x03\x02\x02\x02:8\x03\x02\x02" +
		"\x02:;\x03\x02\x02\x02;=\x03\x02\x02\x02<:\x03\x02\x02\x02=>\x07\b\x02" +
		"\x02>\r\x03\x02\x02\x02?@\x07\t\x02\x02@E\x05\x10\t\x02AB\x07\x07\x02" +
		"\x02BD\x05\x10\t\x02CA\x03\x02\x02\x02DG\x03\x02\x02\x02EC\x03\x02\x02" +
		"\x02EF\x03\x02\x02\x02FH\x03\x02\x02\x02GE\x03\x02\x02\x02HI\x07\n\x02" +
		"\x02I\x0F\x03\x02\x02\x02JK\x07\x14\x02\x02KL\x07\v\x02\x02LM\x05\x14" +
		"\v\x02M\x11\x03\x02\x02\x02NO\x07\x03\x02\x02OV\x05\x14\v\x02PR\x07\x07" +
		"\x02\x02QS\x05\x14\v\x02RQ\x03\x02\x02\x02RS\x03\x02\x02\x02SU\x03\x02" +
		"\x02\x02TP\x03\x02\x02\x02UX\x03\x02\x02\x02VT\x03\x02\x02\x02VW\x03\x02" +
		"\x02\x02WY\x03\x02\x02\x02XV\x03\x02\x02\x02YZ\x07\x04\x02\x02Z\x13\x03" +
		"\x02\x02\x02[e\x07\x0F\x02\x02\\e\x07\x19\x02\x02]e\x07\x14\x02\x02^e" +
		"\x05\x0E\b\x02_e\x05\x12\n\x02`e\x05\f\x07\x02ae\x07\f\x02\x02be\x07\r" +
		"\x02\x02ce\x07\x0E\x02\x02d[\x03\x02\x02\x02d\\\x03\x02\x02\x02d]\x03" +
		"\x02\x02\x02d^\x03\x02\x02\x02d_\x03\x02\x02\x02d`\x03\x02\x02\x02da\x03" +
		"\x02\x02\x02db\x03\x02\x02\x02dc\x03\x02\x02\x02e\x15\x03\x02\x02\x02" +
		"\n\x19\x1F\':ERVd";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!tscnParser.__ATN) {
			tscnParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(tscnParser._serializedATN));
		}

		return tscnParser.__ATN;
	}

}

export class FileContext extends ParserRuleContext {
	public section(): SectionContext[];
	public section(i: number): SectionContext;
	public section(i?: number): SectionContext | SectionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SectionContext);
		} else {
			return this.getRuleContext(i, SectionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_file; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterFile) {
			listener.enterFile(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitFile) {
			listener.exitFile(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitFile) {
			return visitor.visitFile(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SectionContext extends ParserRuleContext {
	public section_header(): Section_headerContext {
		return this.getRuleContext(0, Section_headerContext);
	}
	public property_(): Property_Context[];
	public property_(i: number): Property_Context;
	public property_(i?: number): Property_Context | Property_Context[] {
		if (i === undefined) {
			return this.getRuleContexts(Property_Context);
		} else {
			return this.getRuleContext(i, Property_Context);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_section; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterSection) {
			listener.enterSection(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitSection) {
			listener.exitSection(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitSection) {
			return visitor.visitSection(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class Section_headerContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(tscnParser.ID, 0); }
	public attribute(): AttributeContext[];
	public attribute(i: number): AttributeContext;
	public attribute(i?: number): AttributeContext | AttributeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(AttributeContext);
		} else {
			return this.getRuleContext(i, AttributeContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_section_header; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterSection_header) {
			listener.enterSection_header(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitSection_header) {
			listener.exitSection_header(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitSection_header) {
			return visitor.visitSection_header(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AttributeContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(tscnParser.ID, 0); }
	public value(): ValueContext {
		return this.getRuleContext(0, ValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_attribute; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterAttribute) {
			listener.enterAttribute(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitAttribute) {
			listener.exitAttribute(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitAttribute) {
			return visitor.visitAttribute(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class Property_Context extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(tscnParser.ID, 0); }
	public value(): ValueContext {
		return this.getRuleContext(0, ValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_property_; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterProperty_) {
			listener.enterProperty_(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitProperty_) {
			listener.exitProperty_(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitProperty_) {
			return visitor.visitProperty_(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InstanceContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(tscnParser.ID, 0); }
	public value(): ValueContext[];
	public value(i: number): ValueContext;
	public value(i?: number): ValueContext | ValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueContext);
		} else {
			return this.getRuleContext(i, ValueContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_instance; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterInstance) {
			listener.enterInstance(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitInstance) {
			listener.exitInstance(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitInstance) {
			return visitor.visitInstance(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DictionaryContext extends ParserRuleContext {
	public pair(): PairContext[];
	public pair(i: number): PairContext;
	public pair(i?: number): PairContext | PairContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PairContext);
		} else {
			return this.getRuleContext(i, PairContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_dictionary; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterDictionary) {
			listener.enterDictionary(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitDictionary) {
			listener.exitDictionary(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitDictionary) {
			return visitor.visitDictionary(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PairContext extends ParserRuleContext {
	public STRING_(): TerminalNode { return this.getToken(tscnParser.STRING_, 0); }
	public value(): ValueContext {
		return this.getRuleContext(0, ValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_pair; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterPair) {
			listener.enterPair(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitPair) {
			listener.exitPair(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitPair) {
			return visitor.visitPair(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArrayContext extends ParserRuleContext {
	public value(): ValueContext[];
	public value(i: number): ValueContext;
	public value(i?: number): ValueContext | ValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueContext);
		} else {
			return this.getRuleContext(i, ValueContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_array; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterArray) {
			listener.enterArray(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitArray) {
			listener.exitArray(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitArray) {
			return visitor.visitArray(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ValueContext extends ParserRuleContext {
	public INT(): TerminalNode | undefined { return this.tryGetToken(tscnParser.INT, 0); }
	public FLOAT_(): TerminalNode | undefined { return this.tryGetToken(tscnParser.FLOAT_, 0); }
	public STRING_(): TerminalNode | undefined { return this.tryGetToken(tscnParser.STRING_, 0); }
	public dictionary(): DictionaryContext | undefined {
		return this.tryGetRuleContext(0, DictionaryContext);
	}
	public array(): ArrayContext | undefined {
		return this.tryGetRuleContext(0, ArrayContext);
	}
	public instance(): InstanceContext | undefined {
		return this.tryGetRuleContext(0, InstanceContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tscnParser.RULE_value; }
	// @Override
	public enterRule(listener: tscnListener): void {
		if (listener.enterValue) {
			listener.enterValue(this);
		}
	}
	// @Override
	public exitRule(listener: tscnListener): void {
		if (listener.exitValue) {
			listener.exitValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: tscnVisitor<Result>): Result {
		if (visitor.visitValue) {
			return visitor.visitValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


